

import java.util.Scanner;
import java.util.Stack;
import java.util.EmptyStackException;

/**
 * Clase que se encarga de realizar los calculos y manejar la expresion a calcular
 */
public class Calculadora
{
    /**
     * Campo de atributos privados
     */
	private
	int length;
	Stack stk;
	String exp, postfix;
        static final String e = "2.71828";

        /**
         * Constructor que se encarga de inicializar el atributo exp con la expresion puesta por el usuario 
         * @param  s Expresion a evaluar
         */
	public Calculadora(String s)
	{
		stk = new Stack();
		exp = s;
		postfix = "";
		length = exp.length();
	}
        
        /**
         * Metodo que pone espacios deacuerdo al caracter que se encuetre en la expresion
         
         */
	public void ponerEspacios()
	{
            String aux = "";
            try
            {
            
		
            if(!tieneOperadores(exp))
            {
                System.out.println("true");
                if(exp.charAt(0) == '(')
                {
                    for(int i =1;i<exp.length();i++)
                    {
                        if(exp.charAt(i)== '^')
                        {
                            exp = "(" + potencia( exp.substring(1, i) , exp.substring(i+1, exp.length()-1))  + ")";
                        }
                        else if(exp.charAt(i) == '!')
                        {
                            exp = "(" + factorial( exp.substring(1, i)) + ")";
                        }
                        else if(exp.charAt(i) == 'x')
                        {
                            if(i==1)
                            {
                                exp = "(" + x10("", exp.substring(i+3, exp.length()-1)) +")";
                            }
                            else
                            {
                                exp = "("+x10(exp.substring(1,i) , exp.substring(i+3, exp.length()-1))+")";
                            }
                        }
                        else if(exp.charAt(i) == 's' && exp.charAt(i+1) == 'q')
                        {
                            exp =  "(" + evaluarRaiz(i+3) + ")";
                        }
                        else if(exp.charAt(i) == 's' && exp.charAt(i+1) == 'i')
                        {
                            exp =  "(" + evaluarSeno(i+2) + ")";
                        }
                        else if(exp.charAt(i) == 'c' && exp.charAt(i+1) == 'o')
                        {
                            exp =  "(" + evaluarCoseno(i+2) + ")";
                        }
                        else if(exp.charAt(i) == 't' && exp.charAt(i+1) == 'a')
                        {
                            exp =  "(" + evaluarTangente(i+2) + ")";
                        }
                        else if(exp.charAt(i) == 'l' && exp.charAt(i+1) == 'o')
                        {
                            exp =  "(" + evaluarLog(i+2, 1) + ")";
                        }
                        else if(exp.charAt(i) == 'l' && exp.charAt(i+1) == 'n')
                        {
                            exp =  "(" + evaluarLog(i+1, 2) + ")";
                        }
                        
                    }
                    aux = aux + exp.substring(1, exp.length()-1) + " + 0";
                }
                else if(exp.charAt(0) == 's' && exp.charAt(1) == 'q')
                {
                     aux = aux + "( " + evaluarRaiz(3) + " + 0 )";
                }
                else if(exp.charAt(0) == 's' && exp.charAt(1) == 'i')
                {
                     aux = aux + "( " + evaluarSeno(2) + " + 0 )";
                }
                else if(exp.charAt(0) == 'c' && exp.charAt(1) == 'o')
                {
                     aux = aux + "( " + evaluarCoseno(2) + " + 0 )";
                }
                else if(exp.charAt(0) == 't' && exp.charAt(1) == 'a')
                {
                     aux = aux + "( " + evaluarTangente(2) + " + 0 )";
                }
                else if(exp.charAt(0) == 'l' && exp.charAt(1) == 'o')
                {
                     aux = aux + "( " + evaluarLog(2, 1) + " + 0 )";
                }
                else if(exp.charAt(0) == 'l' && exp.charAt(1) == 'n')
                {
                     aux = aux + "( " + evaluarLog(1, 2) + " + 0 )";
                }
                else
                {
                    for(int i=0;i<exp.length();i++)
                    {
                        if(exp.charAt(i)== '^')
                        {
                            exp =potencia( exp.substring(0, i) , exp.substring(i+1, exp.length()));
                            break;
                        }
                        else if(exp.charAt(i) == '!')
                        {
                            exp =factorial( exp.substring(0, i));
                        }
                        else if(exp.charAt(i) == 'x')
                        {
                            exp = x10(exp.substring(0,i) , exp.substring(i+3, exp.length()));
                        }
                                                                        
                    }
                    aux = aux + exp + " + 0";
                }
            }
           
            else
            {
		for(int i=0;i<exp.length();i++)
		{
			if(!isNumber(exp.charAt(i)+""))
			{
				if(exp.charAt(i) == '(')
				{
                                    
                                    if(exp.charAt(i+1) == '-')
                                    {
                                        aux = aux + "( 0 ";
                                    }
                                    else
					aux = aux + "( ";
				}
				else if(exp.charAt(i) == ')')//3+sqrt(2+sqrt(4))
				{
					aux = aux + " )";
				}
				else if(exp.charAt(i) == '.')
				{
					aux = aux + ".";
				}
                                else if(exp.charAt(i) == 's' && exp.charAt(i+1) == 'q')
                                {
                                    aux = aux + "( " + evaluarRaiz(i+3)+" + 0 )";
                                    while(exp.charAt(i) != ')')
                                        i++;
                                }
                                else if(exp.charAt(i) == 's' && exp.charAt(i+1) == 'i')
                                {
                                    aux = aux + "( " + evaluarSeno(i+2)+" + 0 )";
                                    while(exp.charAt(i) != ')')
                                        i++;
                                }
                                else if(exp.charAt(i) == 'c' && exp.charAt(i+1) == 'o')
                                {
                                    aux = aux + "( " + evaluarSeno(i+2)+" + 0 )";
                                    while(exp.charAt(i) != ')')
                                        i++;
                                }
                                else if(exp.charAt(i) == 't' && exp.charAt(i+1) == 'a')
                                {
                                    aux = aux + "( " + evaluarTangente(i+2)+" + 0 )";
                                    while(exp.charAt(i) != ')')
                                        i++;
                                }
                                else if(exp.charAt(i) == 'l' && exp.charAt(i+1) == 'o')
                                {
                                    aux = aux + "( " + evaluarLog(i+2, 1)+" + 0 )";
                                    while(exp.charAt(i) != ')')
                                        i++;
                                }
                                else if(exp.charAt(i) == 'l' && exp.charAt(i+1) == 'n')
                                {
                                    aux = aux + "( " + evaluarLog(i+1, 2)+" + 0 )";
                                    while(exp.charAt(i) != ')')
                                        i++;
                                }
                                else if(exp.charAt(i) == '-')
                                {
                                    if(i==0)
                                    {
                                        if(exp.charAt(i+1) == '(')
                                        {
                                            aux = aux + "0 - ";
                                        }
                                        else
                                            aux = aux + "0 + -";
                                    }
                                    else if(isOperator(exp.charAt(i-1)))
                                    {
                                        if(exp.charAt(i+1) == '(')
                                        {
                                            aux = aux + "- ";
                                        }
                                        else
                                            aux = aux + "-";
                                    }
                                    else
                                        aux = aux + " " + exp.charAt(i) + " ";
                                }
                                else if(exp.charAt(i)=='^')
                                {
                                    
                                    if(aux.length()!= 0)
                                        aux = aux.substring(0,aux.length()-1);
                                    System.out.println(aux+"<-aux");
                                    int ini = i-1;
                                    while(ini >= 0 &&isNumber(exp.charAt(ini)+""))
                                        ini--;
                                    if(ini<0)
                                        ini=0;
                                   
                                    int end = i+1;
                                    while(end < exp.length() && isNumber(exp.charAt(end)+""))
                                        end++;
                                    
                                    System.out.println(exp.substring(ini+1, i) +  exp.substring(i+1, end));
                                    aux = aux + potencia( exp.substring(ini+1, i) , exp.substring(i+1, end));
                                    i=end-1;
                                }
                                else if(exp.charAt(i) == 'x')
                                {
                                    if(aux.length()!= 0)
                                        aux = aux.substring(0,aux.length()-1);
                                    System.out.println(aux+"<-aux");
                                    int ini = i-1;
                                    while(ini >= 0 && isNumber(exp.charAt(ini)+""))
                                        ini--;
                                    
                                   System.out.println(ini);
                                    int end = i+3;
                                    while(end < exp.length() && isNumber(exp.charAt(end)+""))
                                        end++;
                                    if(ini<0)
                                    {
                                        System.out.println("" +  exp.substring(i+3, end));
                                        aux = aux + x10( "" , exp.substring(i+3, end));
                                    }
                                    else
                                    {
                                        System.out.println(exp.substring(ini+1, i) +  exp.substring(i+3, end));
                                        aux = aux + " " +x10( exp.substring(ini+1, i) , exp.substring(i+3, end));
                                    }
                                    i=end-1;
                                }
				else if(isOperator(exp.charAt(i)))
					aux = aux + " " + exp.charAt(i) + " ";
			}
			else
			{
				aux = aux + exp.charAt(i)+"";
			}
		}
            }
            }
            catch(Exception e)
            {
                aux = "Syntax error";
            }
            System.out.println(aux);
            exp = aux;
            length = exp.length();
            
           
	}
        /**
         * Calcula es procentaje de una expresion
         * @param  r expresion a calcular el procentaje
         
         * @return  el resultado al haber calculado el porcentaje
         */
        public static String porcentaje(String r)
	  {
	     double val = Double.parseDouble(r);
		 String res="";
		 if(val <1)
		 {
		     val=val*100;
		 }
		 
		 res=String.valueOf(val)+"%";
		 return res;
	  }
	  
        /**
         * Evalua una expresion llamando al metodo log() y asi calculando el logaritmo
         * @param  index indice en el que se encuentra el logaritmo en la expresion
         * @param tipo tipo de logaritm, normal o natural
         * @return  el resultado de la expresion al evaluar el logaritmo
         */
        public String evaluarLog(int index, int tipo)
        {
            try
            {
            int i;
            int j=0;
            for(i = index;i<exp.length();i++)  
            {
                if(exp.charAt(i) == ')')
                    break;
                else if(exp.charAt(i) =='(')
                    j=i;
            }
            String base;
            String logArg = exp.substring(j, i+1);
            if(tipo ==1)
                base = exp.substring(index+1, j);
            else 
                base = e;
            
            System.out.println("Base="+base + ", arg="+logArg);
            Calculadora calc = new Calculadora(logArg);
            calc.ponerEspacios();
	    if(calc.isBalance())
            {
			calc.postfixExpression();
			if(!calc.evaluateRPN())
			{
                            return "syntax error";
			}
			else
                        {
                            double v = calc.getDoubleResult();
                            if(v<0||Double.parseDouble(base) < 2) 
                            {
                                return "syntax error";
                            }
                            else
                            {
                                String res = Log(v+"",base);
                                System.out.println(res);
                                return res;
                            }
                            
                        }
            }
            else
                return "systax error";
            }
            catch(EmptyStackException e)
            {
                return "syntax error";
            }
            catch(StringIndexOutOfBoundsException e)
            {
                return "syntax error";
            }
        }
        
        /**
         * Metodo que se encarga de calcular el logaritmo de una expresion
         * @param  num numero a calcular
         * @param base base del logaritmo
         * @return  resultado del logaritmo
         */
        public static String Log(String num, String base)
	 {
		 int i =0;
		 double aux= Double.parseDouble(num);
		 double aux2= Double.parseDouble(base);
		 String l="";
		 if((aux>0)&&(aux2>1))
		 {
		     if(aux>aux2)
		    {
		         for(i=0;aux>=aux2;i++)
		        {
		             aux=aux/aux2;
		        }
			 
	        }
		 
             l = l+Integer.toString(i)+".";
		     aux=potencia(aux,10);
		
		     for(int j=0;j<3;j++)
		    { 
		    
    		     if(aux>aux2)
		         {
		     
			         for(i=0;aux>=aux2;i++)
		             {
		     
			             aux=aux/aux2;
		            }
		         }
		         else
		        {
		             i=0;
		        }
			
			 
			     aux=potencia(aux,10);
			
			     l = l+Integer.toString(i);
		    }
		}
		else
		{
		     l="Math error";
		}
		 return l;
		
	 }
        
         /**
         * Evalua una expresion llamando al metodo tan() y asi calculando la tangente
         * @param  index indice donde se encuentra la tangente en la expresion exp
         * @return  resultado al evaluar la tangente
         */
        public String evaluarTangente(int index)
        {
        try
            {
            int i;
            for(i = index;i<exp.length();i++)  
            {
                if(exp.charAt(i) == ')')
                    break;
            }
            System.out.println(exp.substring(index+1, i+1));
            Calculadora calc = new Calculadora(exp.substring(index+1, i+1));
            calc.ponerEspacios();
	    if(calc.isBalance())
            {
			calc.postfixExpression();
			if(!calc.evaluateRPN())
			{
                            return "syntax error";
			}
			else
                        {
                            double v = calc.getDoubleResult();
                            if(((v%180)==90)||((v%180)==-(90))) 
                            {
                                return "syntax error";
                            }
                            else
                            {
                                String res = tan(v+"");
                                System.out.println(res);
                                return res;
                            }
                            
                        }
            }
            else
                return "systax error";
            }
            catch(EmptyStackException e)
            {
                return "syntax error";
            }
            catch(StringIndexOutOfBoundsException e)
            {
                return "syntax error";
            }
        }
        
        /**
         * Metodo que se encarga de calcular la tangente de una expresion
         * @param  val el valor a calcular
         * @return  el resultado 
         */
        public static String tan(String val)
	  {
	     double v = Double.parseDouble(val);
		 String fin="";
		 double res=0;
		 if(((v%180)==90)||((v%180)==-(90))) 
		{
		     fin="Math Error";
		}
		else
		{
		     String c1 = cosinus(val);
			 String c2 = seno(val);
			 double cos1=Double.parseDouble(c1);
			 double sen1=Double.parseDouble(c2);
			 res=sen1/cos1;
			 fin=String.valueOf(res);
		}
		
		return fin;
	  
	  }
        
         /**
         * Evalua una expresion llamando al metodo cosinus() y asi calculando el coseno
         * @param  index indice donde se encuetra el coseno en la expresion
         * @return  el resultado al evaluar el coseno
         */
        public String evaluarCoseno(int index)
        {
            try
            {
            int i;
            for(i = index;i<exp.length();i++)  
            {
                if(exp.charAt(i) == ')')
                    break;
            }
            System.out.println(exp.substring(index+1, i+1));
            Calculadora calc = new Calculadora(exp.substring(index+1, i+1));
            calc.ponerEspacios();
	    if(calc.isBalance())
            {
			calc.postfixExpression();
			if(!calc.evaluateRPN())
			{
                            return "syntax error";
			}
			else
                        {
                            String res = cosinus(calc.getDoubleResult()+"");
                            
                            System.out.println(res);
                            return res;
                            
                        }
            }
            else
                return "systax error";
            }
            catch(StringIndexOutOfBoundsException e)
            {
                return "syntax error";
            }
        }
        
         /**
         * Metodo que se encarga de calcular el coseno de una expresion
         * @param  val numero a calcular
         * @return  el resultado
         */
        public static String cosinus (String val) 
      {
         double graus = Double.parseDouble(val); 
         double PI = 3.14159;		 
		 int i;
		 double s = 0;
         int signo = 1;
		 double comp = 90;
		 int coc= -1;
		 int res = -1;
		 String fin;
		 
		 if(((graus%180)==90)||((graus%180)==-(90))) 
		{
		     s=0;
		}
		else
		{
		     coc = (int)graus/180;
			 res = (int)graus%180;
			 //System.out.println(res);
			 
			if(res<=90)
		    {
				 graus =(res);
		    }
		
		    if(graus%90==0)
		    {
		         graus=1;
		    }
             graus=graus*(PI/180);
             for(i=0; i<10; i+=2)
             {
                 s += signo*potencia(graus, i) / factorial(i);
                 signo *= -1;
             }
		 
		     if(((res>90)||(res==0))&&(coc%2!=0))
		     {
		     s=-s;
		     }
		 }
		 
         fin=String.valueOf(s);
		 return fin;
      
      }
        
        /**
         * Evalua una expresion llamando al metodo sen() y asi calculando el seno
         * @param  index indice donde se encuentra el seno
         * @return  el resultado al evaluar seno
         */
        public String evaluarSeno(int index)
        {
            try
            {
            int i;
            for(i = index;i<exp.length();i++)  
            {
                if(exp.charAt(i) == ')')
                    break;
            }
            System.out.println(exp.substring(index+1, i+1));
            Calculadora calc = new Calculadora(exp.substring(index+1, i+1));
            calc.ponerEspacios();
	    if(calc.isBalance())
            {
			calc.postfixExpression();
			if(!calc.evaluateRPN())
			{
                            return "syntax error";
			}
			else
                        {
                            String res = seno(calc.getDoubleResult()+"");
                            
                            System.out.println(res);
                            return res;
                            
                        }
            }
            else
                return "systax error";
            }
            catch(StringIndexOutOfBoundsException e)
            {
                return "syntax error";
            }
        }
       
        /**
         * Calcula el factorial de un numero
         * @param  graus numero a calcular
         * @return  el resultado
         */
        public static double factorial(float graus)
      
      {
	     int i;
		 float fact = 1;
		 for(i=1; i<=graus; i++)
		 {
		     fact *= i;
         }
	     return fact;
      
      }
        
        /**
         * Calcula la potencia
         * @param  b numero a calcular
         * @param e exponente a usar
         * @return  el resultado
         */
       
        public static double potencia(double b, double e)
     {
         double base = b;
		 double exp = e;
		 double constante = b;
		 String resp="";
		 if(exp==0)
		 {
		     base=1;
		 }
		 else
		 {
	         for(int i = 1; i <exp;i++)
	         {
	             base= base*constante;
	         }
		 }
		 return base;
     }
        
        /**
         * Calcula el seno de un numero
         * @param  val numero a calcular
         * @return  el resultado
         */
        public static String seno (String val)
        {
            double graus = Double.parseDouble(val);
            double PI = 3.14159;
            int i;
            double s = 0;
            int signo = 1;
		 double comp = 180;
		 String fin;
		 if((graus>comp) || (graus<(-comp)))
		{
		
		     int coc = (int)graus/180;
			 int res = (int)graus%180;
			 //System.out.println(coc);
			 
			if(coc%2==0)
		    {
				 graus = res;
		    }
			else
		    {
				 graus = (-res);
			}
		}
		
        graus=graus*(PI/180);		
		for(i=1; i<10; i=i+2)
		{
		    s += signo*potencia(graus, i) / factorial(i);
			signo *= -1;
		}
		
		 fin=String.valueOf(s);
		 return fin;
      }
        
        /**
         * Agrega a un numero num1 la cantidad de ceros num2
         * @param  num1 numero
         * @param num2 catidad de ceros
         * @return  el resultado
         */
        public String x10(String num1, String num2)
        {
            
            try
            {
                int n2 = Integer.parseInt(num2);
                String ceros = "";
                for(int i=0;i<n2;i++)
                {
                    ceros = ceros + "0";
                }
                num1 = num1.concat(ceros);
                if(Integer.parseInt(num1)==0)
                    num1 = new String("1").concat(ceros);
                return num1;
            }
            catch(NumberFormatException ex)
            {
                return "syntax error";
            }
            
        }
        
        /**
         * Calcula el inverso de un numero devidiendo uno entre el numero
      
         * @return  resultado
         */
        public String inverso()
        {
            try
            {
            String aux;
            String cad;
            
            int i=exp.length()-1;
            
            if(isNumber(exp))
            {
                 Double res = new Double(1/Double.parseDouble(exp));                
                return res.toString();
            }
            else
            {
                while(i>=0 && (isNumber(exp.charAt(i)+"") || exp.charAt(i) == '.'))
                    i--;
                if(i<0)
                    i=0;
                cad = exp.substring(0,i+1);
                aux = exp.substring(i+1, exp.length());
                Double res = new Double(1/Double.parseDouble(aux));
                
                return cad + res.toString();
            }
            }
            catch(NumberFormatException ex)
            {
                return "syntax error";
            }
        }
        
        /**
         * Calcula la potencia
         * @param  num numero
         * @param pot exponente
         * @return  resultado
         */
        public String potencia(String num, String pot)
        {
            try
            {
            double valor = Double.parseDouble(num);
            double f = valor;
            int n = Integer.parseInt(pot);
            for(int i = 1; i <n;i++)
            {
                f= f*valor;
            }
            Double res = new Double(f);
            return res.toString();
            }
            catch(NumberFormatException e)
            {
                return "syntax error";
            }
        }
        
        /**
         * Calcula el factorial de un numero
         * @param  num numero a calcular
         * @return  el resultado
         */
        public String factorial(String num)
        {
            try
            {
                int f= 1;
                int valor = Integer.parseInt(num);
                for(int i =1; i<=valor;i++)
                {
                    f=i*f;
                }
                Integer res = new Integer(f);
                return res.toString();  
            }
            catch(NumberFormatException e)
            {
                return "factorial error";
            }
        }
        
        /**
         * Metodo que devuelve verdadero si la expresion tiene operadores
         * @param str string a evaluar
         * @return true si tiene operadores, falso de lo contrario 
         */
        public boolean tieneOperadores(String str)
        {
            int i;
            for(i=0; i<str.length();i++)
            {
                if(isOperator(str.charAt(i)))
                {
                    i++;
                    break;
                    
                }
            }
            if(i==str.length())
                return false;        
            return true;          
        }
	
        /**
         * Metodo que devuelve verdadero si los parentesis esta bien puestos
         
         * @return true si tiene los parentesis buenos, false de los contrario
         */
        public boolean isBalance()
	{
		boolean fail = false;
		int index = 0;
		
		try
		{
			while (index < length)
			{
				char ch = exp.charAt(index);
				
				switch(ch)
				{
				case ')':
                                    stk.pop();
                                    break;

                                case '(':
                                    stk.push(new Character(ch));
                                    break;
                                    
                                default:
                                    break;
				}
				index++;
			}
		}
		catch(EmptyStackException e)
		{
			fail = true;
		}
                catch(StringIndexOutOfBoundsException e)
		{
			fail = true;
		}
		return stk.empty() && !fail;
	}
        /**
         * Metodo que devuelve verdadero si los parentesis esta bien puestos
         * @param len tamaño de la expresion 
         * @return true si tiene los parentesis buenos, false de lo contrario
         */
        public boolean isBalance(int len)
	{
		boolean fail = false;
		int index = 0;
		
		try
		{
			while (index < len)
			{
				char ch = exp.charAt(index);
				
				switch(ch)
				{
				case ')':
                    stk.pop();
                    break;

                case '(':
                    stk.push(new Character(ch));
                    break;

                default:
                	break;
				}
				index++;
			}
		}
		catch(EmptyStackException e)
		{
			fail = true;
		}
		return stk.empty() && !fail;
	}
        /**
         * Metodo que se encarga de pasar una expresion normal a postfija
         */
	public void postfixExpression()
	{
            try
		{
		String token = "";
		Scanner scan = new Scanner(exp);
		stk.clear();

		while(scan.hasNext())
		{
			token = scan.next();
			char current = token.charAt(0);
			if (isNumber(token))
			{
				postfix = postfix + token + " ";
			}
			else if(isParentheses(current))
			{
				if(current == '(')
				{
					stk.push(current);
				}
				else
				{
					
					Character ch = (Character)stk.peek();
					char nextToken = ch.charValue();
					while(nextToken != '(')
					{
						postfix = postfix + stk.pop() + " ";

						ch = (Character)stk.peek();

						nextToken = ch.charValue();
					}
					stk.pop();
				}
			}
			else
			{
				if(stk.empty())
				{
					stk.push(current);
				}
				else
				{
					Character ch = (Character)stk.peek();
					char top = ch.charValue();

					if(hasHigherPrecedence(top, current))
					{
						stk.push(current);
					}
					else
					{
						ch = (Character)stk.pop();

						top = ch.charValue();

						stk.push(current);

						//stk.push(top);
						postfix = postfix + top + " ";
					}
				}
			}
		}
		
			Character ch = (Character)stk.peek();
			char nextToken = ch.charValue();

			while(isOperator(nextToken))
			{
				postfix = postfix + stk.pop() + " ";
				ch = (Character)stk.peek();
				nextToken = ch.charValue();
			}
		}catch(EmptyStackException e){
                    
                }
	}
	
        /**
         * Metodo que se encarga ver si un string s es un numero o no
         * @param s string a evaluar
         * @return true es un numero, false de lo contrario
         */
        public boolean isNumber(String s)
	{
		try
		{
			double d = Double.parseDouble(s);
			//int Num = Integer.parseInt(s);
		}
		catch(NumberFormatException e)
		{
			return false;
		}
		return true;
	}

        /**
         * Metodo que se encarga de evaluar la notacion postfija y guardar el resultado 
         
         * @return true si se logro evaluar, false de lo contrario 
         */
	public boolean evaluateRPN()
	{
		Scanner scan = new Scanner(postfix);
		String token = "";
		stk.clear();

		while(scan.hasNext())
		{
			try
			{
				token = scan.next();
				if (isNumber(token))
				{
					stk.push(token);
				}
				else
				{
					char current = token.charAt(0);
					double t1 = Double.parseDouble(stk.pop().toString());
					double t2 = Double.parseDouble(stk.pop().toString());
					double t3 = 0;

					switch(current)
					{
					case'+':
					{
						t3 = t2 + t1;
						stk.push(t3);
						break;
					}
					case'-':
					{
						t3 = t2 - t1;
						stk.push(t3);
						break;
					}
					case'*':
					{
						t3 = t2 * t1;
						stk.push(t3);
						break;
					}
					case'/':
					{
						t3 = t2 / t1;
						stk.push(t3);
						break;
					}
                                       
                                        case'm':
					{
						t3 = t2 % t1;
						stk.push(t3);
						break;
					}
					default:
					{
						System.out.println("No se pudo eveluar la notacion polaca.");
					}
					}
				}

			}

			catch(EmptyStackException e){
				return false;
			}
		}
		return true;
	}
	
        /**
         * Metodo que devuelve el resultado directo del stack
         
         * @return string con el resultado
         */
        public String getResult()
	{
		return stk.toString();
	}
        
        /**
         * Metodo que se encargar de resolver la raiz 
         * @param index indice donde se encuentra la raiz en la expresion
         * @return resultado 
         */
        public String evaluarRaiz(int index)
        {
            try
            {
            int i;
            for(i = index;i<exp.length();i++)  
            {
                if(exp.charAt(i) == ')')
                    break;
            }
            System.out.println(exp.substring(index+1, i+1));
            Calculadora calc = new Calculadora(exp.substring(index+1, i+1));
            calc.ponerEspacios();
	    if(calc.isBalance())
            {
			calc.postfixExpression();
			if(!calc.evaluateRPN())
			{
                            return "syntax error";
			}
			else
                        {
                            double num =  calc.getDoubleResult();
                            if(num>=0)
                            {
                                double precision = 0.00001, guess = num/2, change = num/4;
                                while ((guess*guess - num > precision) || (num - guess*guess > precision)) {     
                                guess += (guess * guess > num) ? -change : change;
                                change /= 2;
                                }
                                Double res = new Double(guess);
                                System.out.println(res);
                                return res.toString();
                            }
                            else 
                                return "syntax error";
                        }
            }
            else
                return "systax error";
            }
            catch(StringIndexOutOfBoundsException e)
            {
                return "syntax error";
            }
		
        }
	
        /**
         * Metodo que se encarga de devolver el resultado en forma de double
         
         * @return resultado
         */
        public Double getDoubleResult()
	{
		return (Double)stk.pop();
	}

        /**
         * Metodo que se encarga de devolver el tamano del stack
         
         * @return tamaño de stk
         */
	public int stackSize()
	{
		return stk.size();
	}

        /**
         * Metodo que se encarga de ver si un caracter es un parentesis
         * @param current carecter a evaluar 
         * @return true si es parentesis, false de lo contrario
         */
	public boolean isParentheses(char current)
	{
		if((current == '(') || (current == ')'))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

        /**
         * Metodo que se devuelve true si un caracter es un operador
         * @param ch caracter a evaluar
         * @return true si es operador, false de lo contrario
         */
	public boolean isOperator(char ch)
	{
		if((ch == '-'))
		{
			return true;
		}
		else if((ch == '+'))
		{
			return true;
		}
		else if((ch == '*'))
		{
			return true;
		}
		else if((ch == '/'))
		{
			return true;
		}
                
                else if((ch == 'm'))
                {
                    return true;
                }
		else
		{

		}
		return false;
	}
        
        /**
         * Metodo que devulve true si un caracter tiene mayor procedencia que otro en el stack
         * @param top caracter a evaluar 
         * @param current caracter a evaluar 
         * @return true si current tiene mayor precedencia, false de lo contrario
         */
	public boolean hasHigherPrecedence(char top, char current)
	{
		boolean HigherPre = false;

		switch(current)
		{
                
		case '*':
			HigherPre = true;
			break;

		case '/':
			HigherPre = true;
			break;

		case '+':

			if((top == '*') || (top == '/') || (top == '-'))
			{
				HigherPre = false;
			}
			else
			{
				HigherPre = true;
			}

			break;

		case'-':
			if((top == '*') || (top == '/')|| (top == '-'))
			{
				HigherPre = false;
			}
			else
			{
				HigherPre = true;
			}
			break;

		default:
			System.out.println("No se pudo evaluar la notacion polaca.");
			break;
		}

		return HigherPre;
	}

       
        /**
         * Devuleve la expresion postfija
         * @param 
         * @param 
         * @return expresion postfija
         */
	public String getPostfix()
	{
		return postfix;
	}
        
        
	
}